Node.js Promises

वादों के साथ अतुल्यकालिक प्रोग्रामिंग को सरल बनाएं

वादों का परिचय

Node.js , .

वादे एक अतुल्यकालिक ऑपरेशन के पूरा होने (या विफलता) और उसके अंत का प्रतिनिधित्व करते हैं।

लंबित

आरंभिक स्थिति, ऑपरेशन समाप्त नहीं हुआ है

पुरा होना।

परिचालन सफलतापूर्वक पूरा हुआ

अस्वीकार कर दिया

ऑपरेशन विफल रहा

💡महत्वपूर्ण नोट:

किसी वादे के निर्धारित (पूरा या अस्वीकृत) हो जाने के बाद, उसकी स्थिति नहीं बदलती है।

वादों का उपयोग करने के लाभ

कॉलबैक के साथ

getUser(id, (err, user) => {
  if (err) return handleError(err);
  getOrders(user.id, (err, orders) => {
    if (err) return handleError(err);
    // Process orders...
  });
});

वादों के साथ

getUser(id)
  .then(user => getOrders(user.id))
  .then(orders => processOrders(orders))
  .catch(handleError);

फ्लैट कोड संरचना

कॉलबैक नरक से बचें

बेहतर त्रुटि प्रबंधन

एक .catch() के साथ

कार्यों को संयोजित करना आसान है

यौगिक और श्रृंखला संचालन

समानांतर संचालन

अंतर्निहित समर्थन

कॉलबैक नरक का उदाहरण (वादे के बिना)

fs.readFile('file1.txt', (err, data1) => {
  if (err) throw err;
  fs.readFile('file2.txt', (err, data2) => {
    if (err) throw err;
    fs.readFile('file3.txt', (err, data3) => {
      if (err) throw err;
      // Use data1, data2, and data3
    });
  });
});

⚠️समस्याएँ:

  • नेस्टेड कोड को बनाए रखना कठिन है
  • त्रुटि प्रबंधन पुनरावर्ती है
  • पठनीयता ख़राब है
  • कार्यों को संयोजित करना कठिन है

वादे बनाना और उनका उपयोग करना

प्रॉमिस कंस्ट्रक्टर का उपयोग करके वादे बनाए जा सकते हैं, जो दो मापदंडों के साथ एक फ़ंक्शन को स्वीकार करता है: संकल्प और अस्वीकार।

मूल वचन निर्माण

// Create a new Promise
const myPromise = new Promise((resolve, reject) => {
  // Simulate an async operation (e.g., API call, file read)
  setTimeout(() => {
    const success = Math.random() > 0.5;
    
    if (success) {
      resolve('Operation completed successfully');
    } else {
      reject(new Error('Operation failed'));
    }
  }, 1000); // Simulate delay
});

// Using the Promise
myPromise
  .then(result => console.log('Success:', result))
  .catch(error => console.error('Error:', error.message));

उदाहरण: वादों के साथ फाइल आगे बढ़ना

const fs = require('fs').promises;
const promise1 = Promise.resolve('First result');
const promise2 = new Promise((resolve) => setTimeout(() => resolve('Second result'), 1000));
const promise3 = fs.readFile('myfile.txt', 'utf8');

Promise.all([promise1, promise2, promise3])
  .then(results => {
    console.log('Results:', results);
    // results[0] is from promise1
    // results[1] is from promise2
    // results[2] is the content of myfile.txt
  })
  .catch(error => {
    console.error('Error in one of the promises:', error);
  });

वादा जंजीर

वादों को एक कतार में अतुल्यकालिक संचालन निष्पादित करने के लिए जंजीर में बांधा जा सकता है, प्रत्येक .then() पुले का ऑपरेशन का परिणाम प्राप्त करता है।

उदाहरण: वचनबद्धता

function getUser(userId) {
  return new Promise((resolve, reject) => {
    // Simulating database call
    setTimeout(() => {
      resolve({ id: userId, name: 'John' });
    }, 1000);
  });
}

function getUserPosts(user) {
  return new Promise((resolve, reject) => {
    // Simulating API call
    setTimeout(() => {
      resolve(['Post 1', 'Post 2', 'Post 3']);
    }, 1000);
  });
}

// Chain the promises
getUser(123)
  .then(user => {
    console.log('User:', user);
    return getUserPosts(user);
  })
  .then(posts => {
    console.log('Posts:', posts);
  })
  .catch(error => {
    console.error('Error:', error);
  });

वादा करने के तरीके

घटना के तरीके

  • then(onFulfilled, onRejected)- पूर्ति या अस्वीकृति को संभालता है
  • catch(onRejected)- अस्वीकरणों को संभालता है
  • finally(onFinally)- वादा तय होने के बाद चलता है

मानक तरीके

  • Promise.all(iterable)- सभी वादे पूरे होने तक इंतजार करें
  • Promise.race(iterable)- पहला वादा तय होने का इंतजार है
  • Promise.allSettled(iterable)- सब कुछ तय होने का इंतजार है

उपयोग के तरीके

  • Promise.resolve(value)- एक सुलझा हुआ वादा बनाता है
  • Promise.reject(reason)- एक अस्वीकृत वादा बनाता है

Promise.then()

तत्कालीन() विधि में दो तर्क लगते हैं। वादे की सफलता और विफलता की घटनाओं के लिए तर्क कॉलबैक फ़ंक्शन हैं।

myPromise
  .then(
    result => console.log(result),
    error => console.error(error)
  );

Promise.catch()

कैच() विधि अस्वीकृत वादों को संभालती है और .then(null, errorHandler) के बराबर है।

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

Promise.finally()

आख़िरकार() विधि कोड को निष्पादित करती है, भले ही वादा पूरा हुआ हो या अस्वीकार किया गया हो।

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error))
  .finally(() => console.log('Operation completed'));

समानांतर संचालन के लिए Promise.all()

Promise.all() , . .

उदाहरण: कई वादों को समानांतर में चलाना

const fs = require('fs').promises;
const promise1 = Promise.resolve('First result');
const promise2 = new Promise((resolve) => setTimeout(() => resolve('Second result'), 1000));
const promise3 = fs.readFile('data.txt', 'utf8');

Promise.all([promise1, promise2, promise3])
  .then(results => {
    console.log('Results:', results);
    // results[0] is from promise1
    // results[1] is from promise2
    // results[2] is the content of data.txt
  })
  .catch(error => {
    console.error('Error in one of the promises:', error);
  });

पहले परिणाम के लिए Promise.race()

Promise.race() , .

उदाहरण: Promise.race() के साथ टाइमआउट विधि

const promise1 = new Promise(resolve => setTimeout(() => resolve('First result'), 1000));
const promise2 = new Promise(resolve => setTimeout(() => resolve('Second result'), 500));

Promise.race([promise1, promise2])
  .then(result => {
    console.log('Fastest result:', result);
    // Will log 'Second result' because promise2 is faster
  });

वादों में त्रुटि प्रबंधन

उचित त्रुटि प्रबंधन महत्वपूर्ण है. वादे त्रुटियों से निपटने के कई तरीके प्रदान करते हैं:

उदाहरण: एक वादे में त्रुटि प्रबंधन

function fetchData() {
  return new Promise((resolve, reject) => {
    // Simulating an error
    reject(new Error('Network error'));
  });
}

fetchData()
  .then(
    data => console.log('Data:', data),
    error => console.log('Error handled in then:', error.message)
  );

// Alternative method using catch
fetchData()
  .then(data => console.log('Data:', data))
  .catch(error => console.log('Error handled in catch:', error.message));

🚨सर्वश्रेष्ठ प्रणालियां:

वादों के साथ .catch() का उपयोग करते समय, हैंडल न किए गए वादे को अस्वीकार करने से रोकने के लिए त्रुटि प्रबंधन जोड़ें, जो मौन विफलताओं और मेमोरी लीक का कारण बनता है।

सारांश

वादे

अतुल्यकालिक संचालन के लिए शुद्ध कोड

चेनिंग

एकाधिक अतुल्यकालिक परिचालनों को संयोजित करने में सक्षम बनाता है

समानांतर

Promise.all() Promise.race()

त्रुटि प्रबंधन

एकल .catch() के साथ केंद्रीकृत

💎महत्वपूर्ण बिंदु:

  • वादे कॉलबैक नरक से बचते हैं
  • चेनिंग अनुक्रमिक संचालन को सरल बनाती है
  • Promise.all()
  • .catch() के साथ त्रुटियों को संभालते समय
  • अंततः() कोड साफ़ करने के लिए उपयोगी है

अभ्यास

❓सही स्थिति चुनें.

कोई वादा तीन स्थितियों में से एक में हो सकता है: लंबित,______, या अस्वीकृत.

हल किया
✗ ग़लत! "समाधान" कोई वादा स्थिति नहीं है
पुरा होना।
✓ ठीक है! वादे की स्थितियाँ: लंबित, पूर्ण, या अस्वीकृत
हो गया
✗ ग़लत! "हो गया" कोई वादा स्थिति नहीं है
कार्यान्वित
✗ ग़लत! "निष्पादित" कोई वादा स्थिति नहीं है